home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / WarpQuake / Src / pr_exec.c < prev    next >
C/C++ Source or Header  |  2000-05-22  |  12KB  |  669 lines
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20.  
  21. #include "quakedef.h"
  22.  
  23.  
  24. /*
  25.  
  26. */
  27.  
  28. typedef struct
  29. {
  30.     int                s;
  31.     dfunction_t        *f;
  32. } prstack_t;
  33.  
  34. #define    MAX_STACK_DEPTH        32
  35. prstack_t    pr_stack[MAX_STACK_DEPTH];
  36. int            pr_depth;
  37.  
  38. #define    LOCALSTACK_SIZE        2048
  39. int            localstack[LOCALSTACK_SIZE];
  40. int            localstack_used;
  41.  
  42.  
  43. qboolean    pr_trace;
  44. dfunction_t    *pr_xfunction;
  45. int            pr_xstatement;
  46.  
  47.  
  48. int        pr_argc;
  49.  
  50. char *pr_opnames[] =
  51. {
  52. "DONE",
  53.  
  54. "MUL_F",
  55. "MUL_V", 
  56. "MUL_FV",
  57. "MUL_VF",
  58.  
  59. "DIV",
  60.  
  61. "ADD_F",
  62. "ADD_V", 
  63.   
  64. "SUB_F",
  65. "SUB_V",
  66.  
  67. "EQ_F",
  68. "EQ_V",
  69. "EQ_S", 
  70. "EQ_E",
  71. "EQ_FNC",
  72.  
  73. "NE_F",
  74. "NE_V", 
  75. "NE_S",
  76. "NE_E", 
  77. "NE_FNC",
  78.  
  79. "LE",
  80. "GE",
  81. "LT",
  82. "GT", 
  83.  
  84. "INDIRECT",
  85. "INDIRECT",
  86. "INDIRECT", 
  87. "INDIRECT", 
  88. "INDIRECT",
  89. "INDIRECT", 
  90.  
  91. "ADDRESS", 
  92.  
  93. "STORE_F",
  94. "STORE_V",
  95. "STORE_S",
  96. "STORE_ENT",
  97. "STORE_FLD",
  98. "STORE_FNC",
  99.  
  100. "STOREP_F",
  101. "STOREP_V",
  102. "STOREP_S",
  103. "STOREP_ENT",
  104. "STOREP_FLD",
  105. "STOREP_FNC",
  106.  
  107. "RETURN",
  108.   
  109. "NOT_F",
  110. "NOT_V",
  111. "NOT_S", 
  112. "NOT_ENT", 
  113. "NOT_FNC", 
  114.   
  115. "IF",
  116. "IFNOT",
  117.   
  118. "CALL0",
  119. "CALL1",
  120. "CALL2",
  121. "CALL3",
  122. "CALL4",
  123. "CALL5",
  124. "CALL6",
  125. "CALL7",
  126. "CALL8",
  127.   
  128. "STATE",
  129.   
  130. "GOTO", 
  131.   
  132. "AND",
  133. "OR", 
  134.  
  135. "BITAND",
  136. "BITOR"
  137. };
  138.  
  139. char *PR_GlobalString (int ofs);
  140. char *PR_GlobalStringNoContents (int ofs);
  141.  
  142.  
  143. //=============================================================================
  144.  
  145. /*
  146. =================
  147. PR_PrintStatement
  148. =================
  149. */
  150. void PR_PrintStatement (dstatement_t *s)
  151. {
  152.     int        i;
  153.     
  154.     if ( (unsigned)s->op < sizeof(pr_opnames)/sizeof(pr_opnames[0]))
  155.     {
  156.         Con_Printf ("%s ",  pr_opnames[s->op]);
  157.         i = strlen(pr_opnames[s->op]);
  158.         for ( ; i<10 ; i++)
  159.             Con_Printf (" ");
  160.     }
  161.         
  162.     if (s->op == OP_IF || s->op == OP_IFNOT)
  163.         Con_Printf ("%sbranch %i",PR_GlobalString(s->a),s->b);
  164.     else if (s->op == OP_GOTO)
  165.     {
  166.         Con_Printf ("branch %i",s->a);
  167.     }
  168.     else if ( (unsigned)(s->op - OP_STORE_F) < 6)
  169.     {
  170.         Con_Printf ("%s",PR_GlobalString(s->a));
  171.         Con_Printf ("%s", PR_GlobalStringNoContents(s->b));
  172.     }
  173.     else
  174.     {
  175.         if (s->a)
  176.             Con_Printf ("%s",PR_GlobalString(s->a));
  177.         if (s->b)
  178.             Con_Printf ("%s",PR_GlobalString(s->b));
  179.         if (s->c)
  180.             Con_Printf ("%s", PR_GlobalStringNoContents(s->c));
  181.     }
  182.     Con_Printf ("\n");
  183. }
  184.  
  185. /*
  186. ============
  187. PR_StackTrace
  188. ============
  189. */
  190. void PR_StackTrace (void)
  191. {
  192.     dfunction_t    *f;
  193.     int            i;
  194.     
  195.     if (pr_depth == 0)
  196.     {
  197.         Con_Printf ("<NO STACK>\n");
  198.         return;
  199.     }
  200.     
  201.     pr_stack[pr_depth].f = pr_xfunction;
  202.     for (i=pr_depth ; i>=0 ; i--)
  203.     {
  204.         f = pr_stack[i].f;
  205.         
  206.         if (!f)
  207.         {
  208.             Con_Printf ("<NO FUNCTION>\n");
  209.         }
  210.         else
  211.             Con_Printf ("%12s : %s\n", pr_strings + f->s_file, pr_strings + f->s_name);        
  212.     }
  213. }
  214.  
  215.  
  216. /*
  217. ============
  218. PR_Profile_f
  219.  
  220. ============
  221. */
  222. void PR_Profile_f (void)
  223. {
  224.     dfunction_t    *f, *best;
  225.     int            max;
  226.     int            num;
  227.     int            i;
  228.     
  229.     num = 0;    
  230.     do
  231.     {
  232.         max = 0;
  233.         best = NULL;
  234.         for (i=0 ; i<progs->numfunctions ; i++)
  235.         {
  236.             f = &pr_functions[i];
  237.             if (f->profile > max)
  238.             {
  239.                 max = f->profile;
  240.                 best = f;
  241.             }
  242.         }
  243.         if (best)
  244.         {
  245.             if (num < 10)
  246.                 Con_Printf ("%7i %s\n", best->profile, pr_strings+best->s_name);
  247.             num++;
  248.             best->profile = 0;
  249.         }
  250.     } while (best);
  251. }
  252.  
  253.  
  254. /*
  255. ============
  256. PR_RunError
  257.  
  258. Aborts the currently executing function
  259. ============
  260. */
  261. void PR_RunError (char *error, ...)
  262. {
  263.     va_list        argptr;
  264.     char        string[1024];
  265.  
  266.     va_start (argptr,error);
  267.     vsprintf (string,error,argptr);
  268.     va_end (argptr);
  269.  
  270.     PR_PrintStatement (pr_statements + pr_xstatement);
  271.     PR_StackTrace ();
  272.     Con_Printf ("%s\n", string);
  273.     
  274.     pr_depth = 0;        // dump the stack so host_error can shutdown functions
  275.  
  276.     Host_Error ("Program error");
  277. }
  278.  
  279. /*
  280. ============================================================================
  281. PR_ExecuteProgram
  282.  
  283. The interpretation main loop
  284. ============================================================================
  285. */
  286.  
  287. /*
  288. ====================
  289. PR_EnterFunction
  290.  
  291. Returns the new program statement counter
  292. ====================
  293. */
  294. int PR_EnterFunction (dfunction_t *f)
  295. {
  296.     int        i, j, c, o;
  297.  
  298.     pr_stack[pr_depth].s = pr_xstatement;
  299.     pr_stack[pr_depth].f = pr_xfunction;    
  300.     pr_depth++;
  301.     if (pr_depth >= MAX_STACK_DEPTH)
  302.         PR_RunError ("stack overflow");
  303.  
  304. // save off any locals that the new function steps on
  305.     c = f->locals;
  306.     if (localstack_used + c > LOCALSTACK_SIZE)
  307.         PR_RunError ("PR_ExecuteProgram: locals stack overflow\n");
  308.  
  309.     for (i=0 ; i < c ; i++)
  310.         localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
  311.     localstack_used += c;
  312.  
  313. // copy parameters
  314.     o = f->parm_start;
  315.     for (i=0 ; i<f->numparms ; i++)
  316.     {
  317.         for (j=0 ; j<f->parm_size[i] ; j++)
  318.         {
  319.             ((int *)pr_globals)[o] = ((int *)pr_globals)[OFS_PARM0+i*3+j];
  320.             o++;
  321.         }
  322.     }
  323.  
  324.     pr_xfunction = f;
  325.     return f->first_statement - 1;    // offset the s++
  326. }
  327.  
  328. /*
  329. ====================
  330. PR_LeaveFunction
  331. ====================
  332. */
  333. int PR_LeaveFunction (void)
  334. {
  335.     int        i, c;
  336.  
  337.     if (pr_depth <= 0)
  338.         Sys_Error ("prog stack underflow");
  339.  
  340. // restore locals from the stack
  341.     c = pr_xfunction->locals;
  342.     localstack_used -= c;
  343.     if (localstack_used < 0)
  344.         PR_RunError ("PR_ExecuteProgram: locals stack underflow\n");
  345.  
  346.     for (i=0 ; i < c ; i++)
  347.         ((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];
  348.  
  349. // up stack
  350.     pr_depth--;
  351.     pr_xfunction = pr_stack[pr_depth].f;
  352.     return pr_stack[pr_depth].s;
  353. }
  354.  
  355.  
  356. /*
  357. ====================
  358. PR_ExecuteProgram
  359. ====================
  360. */
  361. void PR_ExecuteProgram (func_t fnum)
  362. {
  363.     eval_t    *a, *b, *c;
  364.     int            s;
  365.     dstatement_t    *st;
  366.     dfunction_t    *f, *newf;
  367.     int        runaway;
  368.     int        i;
  369.     edict_t    *ed;
  370.     int        exitdepth;
  371.     eval_t    *ptr;
  372.  
  373.     if (!fnum || fnum >= progs->numfunctions)
  374.     {
  375.         if (pr_global_struct->self)
  376.             ED_Print (PROG_TO_EDICT(pr_global_struct->self));
  377.         Host_Error ("PR_ExecuteProgram: NULL function");
  378.     }
  379.     
  380.     f = &pr_functions[fnum];
  381.  
  382.     runaway = 100000;
  383.     pr_trace = false;
  384.  
  385. // make a stack frame
  386.     exitdepth = pr_depth;
  387.  
  388.     s = PR_EnterFunction (f);
  389.     
  390. while (1)
  391. {
  392.     s++;    // next statement
  393.  
  394.     st = &pr_statements[s];
  395.     a = (eval_t *)&pr_globals[st->a];
  396.     b = (eval_t *)&pr_globals[st->b];
  397.     c = (eval_t *)&pr_globals[st->c];
  398.     
  399.     if (!--runaway)
  400.         PR_RunError ("runaway loop error");
  401.         
  402.     pr_xfunction->profile++;
  403.     pr_xstatement = s;
  404.     
  405.     if (pr_trace)
  406.         PR_PrintStatement (st);
  407.         
  408.     switch (st->op)
  409.     {
  410.     case OP_ADD_F:
  411.         c->_float = a->_float + b->_float;
  412.         break;
  413.     case OP_ADD_V:
  414.         c->vector[0] = a->vector[0] + b->vector[0];
  415.         c->vector[1] = a->vector[1] + b->vector[1];
  416.         c->vector[2] = a->vector[2] + b->vector[2];
  417.         break;
  418.         
  419.     case OP_SUB_F:
  420.         c->_float = a->_float - b->_float;
  421.         break;
  422.     case OP_SUB_V:
  423.         c->vector[0] = a->vector[0] - b->vector[0];
  424.         c->vector[1] = a->vector[1] - b->vector[1];
  425.         c->vector[2] = a->vector[2] - b->vector[2];
  426.         break;
  427.  
  428.     case OP_MUL_F:
  429.         c->_float = a->_float * b->_float;
  430.         break;
  431.     case OP_MUL_V:
  432.         c->_float = a->vector[0]*b->vector[0]
  433.                 + a->vector[1]*b->vector[1]
  434.                 + a->vector[2]*b->vector[2];
  435.         break;
  436.     case OP_MUL_FV:
  437.         c->vector[0] = a->_float * b->vector[0];
  438.         c->vector[1] = a->_float * b->vector[1];
  439.         c->vector[2] = a->_float * b->vector[2];
  440.         break;
  441.     case OP_MUL_VF:
  442.         c->vector[0] = b->_float * a->vector[0];
  443.         c->vector[1] = b->_float * a->vector[1];
  444.         c->vector[2] = b->_float * a->vector[2];
  445.         break;
  446.  
  447.     case OP_DIV_F:
  448.         c->_float = a->_float / b->_float;
  449.         break;
  450.     
  451.     case OP_BITAND:
  452.         c->_float = (int)a->_float & (int)b->_float;
  453.         break;
  454.     
  455.     case OP_BITOR:
  456.         c->_float = (int)a->_float | (int)b->_float;
  457.         break;
  458.     
  459.         
  460.     case OP_GE:
  461.         c->_float = a->_float >= b->_float;
  462.         break;
  463.     case OP_LE:
  464.         c->_float = a->_float <= b->_float;
  465.         break;
  466.     case OP_GT:
  467.         c->_float = a->_float > b->_float;
  468.         break;
  469.     case OP_LT:
  470.         c->_float = a->_float < b->_float;
  471.         break;
  472.     case OP_AND:
  473.         c->_float = a->_float && b->_float;
  474.         break;
  475.     case OP_OR:
  476.         c->_float = a->_float || b->_float;
  477.         break;
  478.         
  479.     case OP_NOT_F:
  480.         c->_float = !a->_float;
  481.         break;
  482.     case OP_NOT_V:
  483.         c->_float = !a->vector[0] && !a->vector[1] && !a->vector[2];
  484.         break;
  485.     case OP_NOT_S:
  486.         c->_float = !a->string || !pr_strings[a->string];
  487.         break;
  488.     case OP_NOT_FNC:
  489.         c->_float = !a->function;
  490.         break;
  491.     case OP_NOT_ENT:
  492.         c->_float = (PROG_TO_EDICT(a->edict) == sv.edicts);
  493.         break;
  494.  
  495.     case OP_EQ_F:
  496.         c->_float = a->_float == b->_float;
  497.         break;
  498.     case OP_EQ_V:
  499.         c->_float = (a->vector[0] == b->vector[0]) &&
  500.                     (a->vector[1] == b->vector[1]) &&
  501.                     (a->vector[2] == b->vector[2]);
  502.         break;
  503.     case OP_EQ_S:
  504.         c->_float = !strcmp(pr_strings+a->string,pr_strings+b->string);
  505.         break;
  506.     case OP_EQ_E:
  507.         c->_float = a->_int == b->_int;
  508.         break;
  509.     case OP_EQ_FNC:
  510.         c->_float = a->function == b->function;
  511.         break;
  512.  
  513.  
  514.     case OP_NE_F:
  515.         c->_float = a->_float != b->_float;
  516.         break;
  517.     case OP_NE_V:
  518.         c->_float = (a->vector[0] != b->vector[0]) ||
  519.                     (a->vector[1] != b->vector[1]) ||
  520.                     (a->vector[2] != b->vector[2]);
  521.         break;
  522.     case OP_NE_S:
  523.         c->_float = strcmp(pr_strings+a->string,pr_strings+b->string);
  524.         break;
  525.     case OP_NE_E:
  526.         c->_float = a->_int != b->_int;
  527.         break;
  528.     case OP_NE_FNC:
  529.         c->_float = a->function != b->function;
  530.         break;
  531.  
  532. //==================
  533.     case OP_STORE_F:
  534.     case OP_STORE_ENT:
  535.     case OP_STORE_FLD:        // integers
  536.     case OP_STORE_S:
  537.     case OP_STORE_FNC:        // pointers
  538.         b->_int = a->_int;
  539.         break;
  540.     case OP_STORE_V:
  541.         b->vector[0] = a->vector[0];
  542.         b->vector[1] = a->vector[1];
  543.         b->vector[2] = a->vector[2];
  544.         break;
  545.         
  546.     case OP_STOREP_F:
  547.     case OP_STOREP_ENT:
  548.     case OP_STOREP_FLD:        // integers
  549.     case OP_STOREP_S:
  550.     case OP_STOREP_FNC:        // pointers
  551.         ptr = (eval_t *)((byte *)sv.edicts + b->_int);
  552.         ptr->_int = a->_int;
  553.         break;
  554.     case OP_STOREP_V:
  555.         ptr = (eval_t *)((byte *)sv.edicts + b->_int);
  556.         ptr->vector[0] = a->vector[0];
  557.         ptr->vector[1] = a->vector[1];
  558.         ptr->vector[2] = a->vector[2];
  559.         break;
  560.         
  561.     case OP_ADDRESS:
  562.         ed = PROG_TO_EDICT(a->edict);
  563. #ifdef PARANOID
  564.         NUM_FOR_EDICT(ed);        // make sure it's in range
  565. #endif
  566.         if (ed == (edict_t *)sv.edicts && sv.state == ss_active)
  567.             PR_RunError ("assignment to world entity");
  568.         c->_int = (byte *)((int *)&ed->v + b->_int) - (byte *)sv.edicts;
  569.         break;
  570.         
  571.     case OP_LOAD_F:
  572.     case OP_LOAD_FLD:
  573.     case OP_LOAD_ENT:
  574.     case OP_LOAD_S:
  575.     case OP_LOAD_FNC:
  576.         ed = PROG_TO_EDICT(a->edict);
  577. #ifdef PARANOID
  578.         NUM_FOR_EDICT(ed);        // make sure it's in range
  579. #endif
  580.         a = (eval_t *)((int *)&ed->v + b->_int);
  581.         c->_int = a->_int;
  582.         break;
  583.  
  584.     case OP_LOAD_V:
  585.         ed = PROG_TO_EDICT(a->edict);
  586. #ifdef PARANOID
  587.         NUM_FOR_EDICT(ed);        // make sure it's in range
  588. #endif
  589.         a = (eval_t *)((int *)&ed->v + b->_int);
  590.         c->vector[0] = a->vector[0];
  591.         c->vector[1] = a->vector[1];
  592.         c->vector[2] = a->vector[2];
  593.         break;
  594.         
  595. //==================
  596.  
  597.     case OP_IFNOT:
  598.         if (!a->_int)
  599.             s += st->b - 1;    // offset the s++
  600.         break;
  601.         
  602.     case OP_IF:
  603.         if (a->_int)
  604.             s += st->b - 1;    // offset the s++
  605.         break;
  606.         
  607.     case OP_GOTO:
  608.         s += st->a - 1;    // offset the s++
  609.         break;
  610.         
  611.     case OP_CALL0:
  612.     case OP_CALL1:
  613.     case OP_CALL2:
  614.     case OP_CALL3:
  615.     case OP_CALL4:
  616.     case OP_CALL5:
  617.     case OP_CALL6:
  618.     case OP_CALL7:
  619.     case OP_CALL8:
  620.         pr_argc = st->op - OP_CALL0;
  621.         if (!a->function)
  622.             PR_RunError ("NULL function");
  623.  
  624.         newf = &pr_functions[a->function];
  625.  
  626.         if (newf->first_statement < 0)
  627.         {    // negative statements are built in functions
  628.             i = -newf->first_statement;
  629.             if (i >= pr_numbuiltins)
  630.                 PR_RunError ("Bad builtin call number");
  631.             pr_builtins[i] ();
  632.             break;
  633.         }
  634.  
  635.         s = PR_EnterFunction (newf);
  636.         break;
  637.  
  638.     case OP_DONE:
  639.     case OP_RETURN:
  640.         pr_globals[OFS_RETURN] = pr_globals[st->a];
  641.         pr_globals[OFS_RETURN+1] = pr_globals[st->a+1];
  642.         pr_globals[OFS_RETURN+2] = pr_globals[st->a+2];
  643.     
  644.         s = PR_LeaveFunction ();
  645.         if (pr_depth == exitdepth)
  646.             return;        // all done
  647.         break;
  648.         
  649.     case OP_STATE:
  650.         ed = PROG_TO_EDICT(pr_global_struct->self);
  651. #ifdef FPS_20
  652.         ed->v.nextthink = pr_global_struct->time + 0.05;
  653. #else
  654.         ed->v.nextthink = pr_global_struct->time + 0.1;
  655. #endif
  656.         if (a->_float != ed->v.frame)
  657.         {
  658.             ed->v.frame = a->_float;
  659.         }
  660.         ed->v.think = b->function;
  661.         break;
  662.         
  663.     default:
  664.         PR_RunError ("Bad opcode %i", st->op);
  665.     }
  666. }
  667.  
  668. }
  669.